home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume18 / olvwm-3.0 / patch2.04 < prev    next >
Encoding:
Text File  |  1992-07-22  |  28.1 KB  |  1,026 lines
  1. Newsgroups: comp.sources.x
  2. Path: uunet!gatech!paladin.american.edu!darwin.sura.net!mips!msi!dcmartin
  3. From: sdo@soliado.East.Sun.COM (Scott Oaks - Sun Consulting NYC)
  4. Subject: v18i051: olvwm 3.0, Patch2, Part04/04
  5. Message-ID: <1992Jul22.153010.19354@msi.com>
  6. Originator: dcmartin@fascet
  7. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  8. Organization: Molecular Simulations, Inc.
  9. References: <csx-18i048-olvwm-3.0@uunet.UU.NET>
  10. Date: Wed, 22 Jul 1992 15:30:10 GMT
  11. Approved: dcmartin@msi.com
  12. Lines: 1012
  13.  
  14. Submitted-by: sdo@soliado.East.Sun.COM (Scott Oaks - Sun Consulting NYC)
  15. Posting-number: Volume 18, Issue 51
  16. Archive-name: olvwm-3.0/patch2.04
  17. Patch-To: olvwm-3.0: Volume 15, Issue 167
  18.  
  19. #!/bin/sh
  20. # this is part.04 (part 4 of a multipart archive)
  21. # do not concatenate these parts, unpack them in order with /bin/sh
  22. # file olvwm3.Patch02 continued
  23. #
  24. if test ! -r _shar_seq_.tmp; then
  25.     echo 'Please unpack part 1 first!'
  26.     exit 1
  27. fi
  28. (read Scheck
  29.  if test "$Scheck" != 4; then
  30.     echo Please unpack part "$Scheck" next!
  31.     exit 1
  32.  else
  33.     exit 0
  34.  fi
  35. ) < _shar_seq_.tmp || exit 1
  36. if test ! -f _shar_wnt_.tmp; then
  37.     echo 'x - still skipping olvwm3.Patch02'
  38. else
  39. echo 'x - continuing file olvwm3.Patch02'
  40. sed 's/^X//' << 'SHAR_EOF' >> 'olvwm3.Patch02' &&
  41. X      if (GRV.VirtualRaiseVDM)
  42. !     RaiseWindow(vdm->client->framewin);
  43. X  }
  44. X  
  45. X  /*
  46. +  * There's another cmpButton in olvwmrc.y, but that comparison checks for
  47. +  * the icon flag and is case insensitive.  We need a simple case sensitive
  48. +  * check here
  49. +  */
  50. + static int
  51. + cmpButton(b1, b2)
  52. +     Button    **b1, **b2;
  53. + 
  54. + {
  55. +     return strcmp(gettext((*b1)->label[0].string),
  56. +           gettext((*b2)->label[0].string));
  57. + }
  58. + 
  59. + /*
  60. X   * Menu generation function for DIRMENU
  61. X   *
  62. X   */
  63. ***************
  64. *** 1797,1803 ****
  65. X  DIR    *dir;
  66. X  struct dirent    *ent;
  67. X  Button    *b;
  68. ! char    s[256], *dirname;
  69. X  extern int AppMenuFunc();
  70. X  
  71. X      MenuInfoDestroy(menuInfo->buttons[bindex].subMenu);
  72. --- 1826,1833 ----
  73. X  DIR    *dir;
  74. X  struct dirent    *ent;
  75. X  Button    *b;
  76. ! char    s[MAXNAMLEN], dirname[MAXPATHLEN - MAXNAMLEN], *newname, *ExpandPath();
  77. ! char    tmp[MAXPATHLEN - MAXNAMLEN], pattern[MAXNAMLEN];
  78. X  extern int AppMenuFunc();
  79. X  
  80. X      MenuInfoDestroy(menuInfo->buttons[bindex].subMenu);
  81. ***************
  82. *** 1811,1825 ****
  83. X      menu->maxLabWidth = 0;
  84. X      menu->prefColSize = 0;
  85. X  
  86. !     dirname = (char *) menuInfo->menu->buttons[bindex]->generate_args;
  87. !     if (!(dir = opendir(dirname))) {
  88. !     menuInfo->buttons[bindex].subMenu =
  89. !                 MenuInfoCreate(cache, winInfo, menu, depth);
  90. !     return;
  91. X      }
  92. X      while (ent = readdir(dir)) {
  93. X      if (ent->d_name[0] == '.')
  94. X          continue;
  95. X      b = (Button *) MemAlloc(sizeof(Button));
  96. X      if (!menu->buttonCount++)
  97. X          menu->buttons = (Button **) MemAlloc(sizeof(Button *));
  98. --- 1841,1873 ----
  99. X      menu->maxLabWidth = 0;
  100. X      menu->prefColSize = 0;
  101. X  
  102. !     pattern[0] = '\0';
  103. !     if ((newname = ExpandPath(menuInfo->menu->buttons[bindex]->generate_args,
  104. !                 True)) == NULL)
  105. !     strcpy(dirname, (char *) menuInfo->menu->buttons[bindex]->generate_args);
  106. !     else {
  107. !     strcpy(dirname, newname);
  108. !     MemFree(newname);
  109. X      }
  110. +     if ((dir = opendir(dirname)) == NULL) {
  111. +     if (newname = strrchr(dirname, '/')) {
  112. +         strcpy(pattern, newname + 1);
  113. +         dirname[strlen(dirname) - strlen(pattern) - 1] = '\0';
  114. +         rexInit(pattern);
  115. +     }
  116. +     if ((newname == NULL) || ((dir = opendir(dirname)) == NULL)) {
  117. +         ErrorWarning(gettext("An invalid directory was named for DIRMENU"));
  118. +         menuInfo->buttons[bindex].subMenu =
  119. +             MenuInfoCreate(cache, winInfo, menu, depth);
  120. +         return;
  121. +     }
  122. +     }
  123. X      while (ent = readdir(dir)) {
  124. X      if (ent->d_name[0] == '.')
  125. X          continue;
  126. +     if (pattern[0] && !rexMatch(ent->d_name))
  127. +         continue;
  128. + 
  129. X      b = (Button *) MemAlloc(sizeof(Button));
  130. X      if (!menu->buttonCount++)
  131. X          menu->buttons = (Button **) MemAlloc(sizeof(Button *));
  132. ***************
  133. *** 1841,1846 ****
  134. --- 1889,1994 ----
  135. X      b->generate_func = NULL;
  136. X      }
  137. X      closedir(dir);
  138. +     if (GRV.VirtualDirSort == SortAlpha)
  139. +     qsort(menu->buttons, menu->buttonCount, sizeof(Button *), cmpButton);
  140. X      menuInfo->buttons[bindex].subMenu =
  141. X                  MenuInfoCreate(cache, winInfo, menu, depth);
  142. + }
  143. + 
  144. + #define INIT   register char *sp = instring;
  145. + #define GETC() (*sp++)
  146. + #define PEEKC()     (*sp)
  147. + #define UNGETC(c)   (--sp)
  148. + #define RETURN(c)   return;
  149. + #define ERROR(val)  regerr(val)
  150. + #define TRUE 1
  151. + #define FALSE 0
  152. + #include <regexp.h>
  153. + 
  154. + static
  155. + regerr(val)
  156. + int val;
  157. + {
  158. +     switch(val) {
  159. +     case 11:
  160. +         ErrorWarning("DIRMENU: Range endpoint too large.\n");
  161. +         break;
  162. +     case 16:
  163. +         ErrorWarning("DIRMENU: Bad number.\n");
  164. +         break;
  165. +     case 25:
  166. +         ErrorWarning("DIRMENU: ``\\ digit'' out of range.\n");
  167. +         break;
  168. +     case 36:
  169. +         ErrorWarning("DIRMENU: Illegal or missing delimiter.\n");
  170. +         break;
  171. +     case 41:
  172. +         ErrorWarning("DIRMENU: No remembered search string.\n");
  173. +         break;
  174. +     case 42:
  175. +         ErrorWarning("DIRMENU: \\( \\) imbalance.\n");
  176. +         break;
  177. +     case 43:
  178. +         ErrorWarning("DIRMENU: Too many \\(.\n");
  179. +         break;
  180. +     case 44:
  181. +         ErrorWarning("DIRMENU: More than 2 numbers given in \\{ \\}.\n");
  182. +         break;
  183. +     case 45:
  184. +         /* { gratutitous brace to match next line for vi */
  185. +         ErrorWarning("DIRMENU: } expected after \\.\n");
  186. +         break;
  187. +     case 46:
  188. +         ErrorWarning("DIRMENU: First number exceeds second in \\{ \\}.\n");
  189. +         break;
  190. +     case 49:
  191. +         ErrorWarning("DIRMENU: [] imbalance.\n");
  192. +         break;
  193. +     case 50:
  194. +         ErrorWarning("DIRMENU: Regular expression too long.\n");
  195. +         break;
  196. +     default:
  197. +         ErrorWarning("DIRMENU: Error code %d returned\n",val);
  198. +         break;
  199. +     }
  200. + }
  201. + 
  202. + static char expbuf[256];
  203. + 
  204. + static
  205. + rexMatch(string)
  206. +     char *string;
  207. + {
  208. +     return step(string,expbuf);
  209. + }
  210. + 
  211. + static
  212. + rexInit(pattern)
  213. +     char *pattern;
  214. + {
  215. + int i, j, n;
  216. + char newPattern[256],tmp[256];
  217. + 
  218. +     strcpy(newPattern,"");
  219. +     n = strlen(pattern);
  220. +     newPattern[0] = '^';
  221. +     for(i = 0, j = 1; i < n; i++) {
  222. +     switch(pattern[i]) {
  223. +         case '?':
  224. +         newPattern[j++] = '.';
  225. +         break;
  226. +         case '*':
  227. +         newPattern[j++] = '.';
  228. +         newPattern[j++] = '*';
  229. +         break;
  230. +         case '.':
  231. +         newPattern[j++] = '\\';
  232. +         newPattern[j++] = '.';
  233. +         break;
  234. +         default:
  235. +         newPattern[j++] = pattern[i];
  236. +     }
  237. +     }
  238. +     newPattern[j++] = '$';
  239. +     compile(newPattern, expbuf, &expbuf[256], '\0');
  240. X  }
  241. *** BUILD/win.h    Sat Jun 13 15:50:19 1992
  242. --- src/win.h    Sat Jun 13 15:43:29 1992
  243. ***************
  244. *** 7,13 ****
  245. X  #ifndef _OLWM_WIN_H
  246. X  #define _OLWM_WIN_H
  247. X  
  248. ! #ident  "@(#)win.h    1.1 olvwm version 1/3/92"
  249. X  
  250. X  /*
  251. X   * Based on
  252. --- 7,13 ----
  253. X  #ifndef _OLWM_WIN_H
  254. X  #define _OLWM_WIN_H
  255. X  
  256. ! #ident  "@(#)win.h    1.2 olvwm version 6/13/92"
  257. X  
  258. X  /*
  259. X   * Based on
  260. ***************
  261. *** 23,30 ****
  262. X      MENU_FULL,     /* Close, Zoom, Props, Scale, Back, Refresh, Quit */
  263. X      MENU_LIMITED,  /* Dismiss, Scale, Refresh */
  264. X      MENU_NONE,
  265. -     MENU_ROOT,       /* used only by usermenu.c */
  266. X      MENU_VDM,       /* used in virtual.c */
  267. X      NUM_MENUS
  268. X  } MenuIndex;
  269. X  
  270. --- 23,33 ----
  271. X      MENU_FULL,     /* Close, Zoom, Props, Scale, Back, Refresh, Quit */
  272. X      MENU_LIMITED,  /* Dismiss, Scale, Refresh */
  273. X      MENU_NONE,
  274. X      MENU_VDM,       /* used in virtual.c */
  275. +     MENU_ROOT,       /* used only by usermenu.c */
  276. +            /* because of rereading menu file, MENU_ROOT must be last
  277. +             * since it has to clear out all menu caches after it
  278. +             */
  279. X      NUM_MENUS
  280. X  } MenuIndex;
  281. X  
  282. ***************
  283. *** 467,472 ****
  284. --- 470,476 ----
  285. X  typedef struct _winvirtual {
  286. X      ClassVirtualPane   *class;
  287. X      WinCore            core;
  288. +     WinPaneCore        pcore;
  289. X  } WinVirtual;
  290. X  
  291. X  typedef enum {upleft, upright, lowleft, lowright, keyevent} WhichResize;
  292. *** BUILD/winbutton.c    Sat Jun 13 15:50:10 1992
  293. --- src/winbutton.c    Sat Jun 13 15:43:29 1992
  294. ***************
  295. *** 4,10 ****
  296. X   *      file for terms of the license.
  297. X   */
  298. X  
  299. ! #ident    "@(#)winbutton.c    1.1 olvwm version 1/3/92"
  300. X  
  301. X  /*
  302. X   * Based on
  303. --- 4,10 ----
  304. X   *      file for terms of the license.
  305. X   */
  306. X  
  307. ! #ident    "@(#)winbutton.c    1.2 olvwm version 6/13/92"
  308. X  
  309. X  /*
  310. X   * Based on
  311. ***************
  312. *** 103,109 ****
  313. X          XGrabPointer(dpy, winInfo->core.self, False,
  314. X           (ButtonReleaseMask | ButtonPressMask | PointerMotionMask),
  315. X           GrabModeAsync, GrabModeAsync, None,
  316. !          GRV.MovePointer, CurrentTime);
  317. X          buttonActive = True;
  318. X          currentAction = a;
  319. X          break;
  320. --- 103,109 ----
  321. X          XGrabPointer(dpy, winInfo->core.self, False,
  322. X           (ButtonReleaseMask | ButtonPressMask | PointerMotionMask),
  323. X           GrabModeAsync, GrabModeAsync, None,
  324. !          GRV.CloseDownPointer, CurrentTime);
  325. X          buttonActive = True;
  326. X          currentAction = a;
  327. X          break;
  328. ***************
  329. *** 174,180 ****
  330. X  
  331. X      if (cli->isFocus)
  332. X          gis = WinGI(winInfo, INPUTFOCUS_GINFO);
  333. !     else gis == WinGI(winInfo,NORMAL_GINFO);
  334. X  
  335. X      if (!event->xmotion.same_screen || currentAction != ACTION_SELECT)
  336. X          return;
  337. --- 174,180 ----
  338. X  
  339. X      if (cli->isFocus)
  340. X          gis = WinGI(winInfo, INPUTFOCUS_GINFO);
  341. !     else gis = WinGI(winInfo,NORMAL_GINFO);
  342. X  
  343. X      if (!event->xmotion.same_screen || currentAction != ACTION_SELECT)
  344. X          return;
  345. ***************
  346. *** 325,331 ****
  347. X  
  348. X          attributes.event_mask =
  349. X          ButtonReleaseMask | ButtonPressMask | ExposureMask;
  350. !     attributes.cursor = GRV.IconPointer;
  351. X          valuemask = CWEventMask | CWCursor;
  352. X  
  353. X          win = XCreateWindow(dpy, par->core.self,
  354. --- 325,331 ----
  355. X  
  356. X          attributes.event_mask =
  357. X          ButtonReleaseMask | ButtonPressMask | ExposureMask;
  358. !     attributes.cursor = GRV.CloseUpPointer;
  359. X          valuemask = CWEventMask | CWCursor;
  360. X  
  361. X          win = XCreateWindow(dpy, par->core.self,
  362. *** BUILD/winframe.c    Sat Jun 13 15:51:10 1992
  363. --- src/winframe.c    Sat Jun 13 15:43:30 1992
  364. ***************
  365. *** 4,10 ****
  366. X   *      file for terms of the license.
  367. X   */
  368. X  
  369. ! #ident    "@(#)winframe.c    1.2 olvwm version 1/27/92"
  370. X  
  371. X  /*
  372. X   * Based on
  373. --- 4,10 ----
  374. X   *      file for terms of the license.
  375. X   */
  376. X  
  377. ! #ident    "@(#)winframe.c    1.3 olvwm version 6/13/92"
  378. X  
  379. X  /*
  380. X   * Based on
  381. ***************
  382. *** 812,819 ****
  383. X      int fy = h-heightBottomFrame(win);
  384. X      int baseline;
  385. X      int margin;
  386. !     int footwidth = w - 2*margin;
  387. !     int qfootwidth = footwidth / 4;
  388. X      int gutter;
  389. X      int rstart, lmaxwidth, rmaxwidth;
  390. X      Graphics_info    *gis;
  391. --- 812,819 ----
  392. X      int fy = h-heightBottomFrame(win);
  393. X      int baseline;
  394. X      int margin;
  395. !     int footwidth;
  396. !     int qfootwidth;
  397. X      int gutter;
  398. X      int rstart, lmaxwidth, rmaxwidth;
  399. X      Graphics_info    *gis;
  400. ***************
  401. *** 834,839 ****
  402. --- 834,841 ----
  403. X      armh = ResizeArm_Height(gis);
  404. X      gutter = ptSize(gis);
  405. X      margin = FRAME_OUTLINE_WIDTH + ptSize(gis);
  406. +     footwidth = w - 2*margin;
  407. +     qfootwidth = footwidth / 4;
  408. X  
  409. X      XFillRectangle(dpy, self, gc,
  410. X          widthLeftFrame(win), fy,
  411. ***************
  412. *** 1532,1538 ****
  413. X      attributes.cursor = GRV.TargetPointer;
  414. X      attributes.border_pixel = 0;
  415. X      attributes.colormap = cli->scrInfo->colormap;
  416. !     if (GRV.PointerWorkspace)
  417. X          valuemask = CWEventMask | CWSaveUnder | CWBackPixmap |
  418. X              CWBorderPixel | CWColormap;
  419. X      else valuemask = CWEventMask | CWSaveUnder | CWBackPixmap | CWCursor |
  420. --- 1534,1540 ----
  421. X      attributes.cursor = GRV.TargetPointer;
  422. X      attributes.border_pixel = 0;
  423. X      attributes.colormap = cli->scrInfo->colormap;
  424. !     if (!GRV.PointerWorkspace)
  425. X          valuemask = CWEventMask | CWSaveUnder | CWBackPixmap |
  426. X              CWBorderPixel | CWColormap;
  427. X      else valuemask = CWEventMask | CWSaveUnder | CWBackPixmap | CWCursor |
  428. *** BUILD/winicon.c    Sat Jun 13 15:50:26 1992
  429. --- src/winicon.c    Sat Jun 13 15:43:30 1992
  430. ***************
  431. *** 4,10 ****
  432. X   *      file for terms of the license.
  433. X   */
  434. X  
  435. ! #ident    "@(#)winicon.c    1.1 olvwm version 1/3/92"
  436. X  
  437. X  /*
  438. X   * Based on
  439. --- 4,10 ----
  440. X   *      file for terms of the license.
  441. X   */
  442. X  
  443. ! #ident    "@(#)winicon.c    1.2 olvwm version 6/13/92"
  444. X  
  445. X  /*
  446. X   * Based on
  447. ***************
  448. *** 731,741 ****
  449. X  {
  450. X      WinIconPane *pane = (WinIconPane *)winIcon->fcore.panewin;
  451. X  
  452. X      XReparentWindow(cli->dpy, pane->core.self, winIcon->core.self,
  453. !             pane->core.x, pane->core.y);
  454. !     XMapWindow(cli->dpy, pane->core.self);
  455. X      if (pane->iconClientWindow && !(cli->flags & CLOlwmOwned))
  456. X          XChangeSaveSet(cli->dpy, pane->core.self, SetModeInsert);
  457. X      MapWindow(winIcon);
  458. X  }
  459. X  
  460. --- 731,744 ----
  461. X  {
  462. X      WinIconPane *pane = (WinIconPane *)winIcon->fcore.panewin;
  463. X  
  464. + #ifdef notdef
  465. +     /* see winipane.c */
  466. X      XReparentWindow(cli->dpy, pane->core.self, winIcon->core.self,
  467. !             pane->core.x, pane->core.y); see winipane.c
  468. X      if (pane->iconClientWindow && !(cli->flags & CLOlwmOwned))
  469. X          XChangeSaveSet(cli->dpy, pane->core.self, SetModeInsert);
  470. + #endif
  471. +     XMapWindow(cli->dpy, pane->core.self);
  472. X      MapWindow(winIcon);
  473. X  }
  474. X  
  475. ***************
  476. *** 752,757 ****
  477. --- 755,778 ----
  478. X      WinIconPane *pane = (WinIconPane *)winIcon->fcore.panewin;
  479. X  
  480. X      UnmapWindow(winIcon);
  481. +     XUnmapWindow(cli->dpy, pane->core.self);
  482. + #ifdef notdef
  483. +     /* see winipane.c */
  484. +     XReparentWindow(cli->dpy, pane->core.self, cli->scrInfo->rootid,
  485. +             winIcon->core.x + pane->core.x,
  486. +             winIcon->core.y + pane->core.y);
  487. +     if (pane->iconClientWindow && !(cli->flags & CLOlwmOwned))
  488. +         XChangeSaveSet(cli->dpy, pane->core.self, SetModeDelete);
  489. + #endif
  490. + }
  491. + 
  492. + void
  493. + IconUnparent(cli, winIcon)
  494. +     Client *cli;
  495. +     WinIconFrame *winIcon;
  496. + {
  497. + WinIconPane *pane = (WinIconPane *)winIcon->fcore.panewin;
  498. + 
  499. X      XUnmapWindow(cli->dpy, pane->core.self);
  500. X      XReparentWindow(cli->dpy, pane->core.self, cli->scrInfo->rootid,
  501. X              winIcon->core.x + pane->core.x,
  502. *** BUILD/winipane.c    Sat Jun 13 15:51:11 1992
  503. --- src/winipane.c    Sat Jun 13 15:43:30 1992
  504. ***************
  505. *** 4,10 ****
  506. X   *      file for terms of the license.
  507. X   */
  508. X  
  509. ! #ident    "@(#)winipane.c    1.2 olvwm version 1/27/92"
  510. X  
  511. X  /*
  512. X   * Based on
  513. --- 4,10 ----
  514. X   *      file for terms of the license.
  515. X   */
  516. X  
  517. ! #ident    "@(#)winipane.c    1.3 olvwm version 6/13/92"
  518. X  
  519. X  /*
  520. X   * Based on
  521. ***************
  522. *** 439,444 ****
  523. --- 439,454 ----
  524. X  
  525. X      /* register the window */
  526. X      WIInstallInfo(w);
  527. + 
  528. +     /* Reparent the pane.  olwm didn't do this; since it never moved the
  529. +      * icon while it was in StateNorm, it could afford to unparent the
  530. +      * icon everytime it went to StateNorm.  We can't do that, or the
  531. +      * icon misses ConfigureNotify events when its not visible
  532. +      */
  533. +     XReparentWindow(cli->dpy, iconPane, par->core.self,
  534. +             w->core.x, w->core.y);
  535. +     if (w->iconClientWindow && !(cli->flags & CLOlwmOwned))
  536. +         XChangeSaveSet(cli->dpy, w->core.self, SetModeInsert);
  537. X  
  538. X      return w;
  539. X  }
  540. *** BUILD/winresize.c    Sat Jun 13 15:50:11 1992
  541. --- src/winresize.c    Sat Jun 13 15:43:31 1992
  542. ***************
  543. *** 4,10 ****
  544. X   *      file for terms of the license.
  545. X   */
  546. X  
  547. ! #ident    "@(#)winresize.c    1.1 olvwm version 1/3/92"
  548. X  
  549. X  /*
  550. X   * Based on
  551. --- 4,10 ----
  552. X   *      file for terms of the license.
  553. X   */
  554. X  
  555. ! #ident    "@(#)winresize.c    1.2 olvwm version 6/13/92"
  556. X  
  557. X  /*
  558. X   * Based on
  559. ***************
  560. *** 240,246 ****
  561. X          ButtonPressMask | ButtonMotionMask | ButtonReleaseMask
  562. X          | ExposureMask | OwnerGrabButtonMask;
  563. X          attributes.win_gravity = whichgrav[which];
  564. !     attributes.cursor = GRV.ResizePointer;
  565. X          valuemask = CWEventMask | CWWinGravity | CWCursor;
  566. X  
  567. X          win = XCreateWindow(dpy, par->core.self,
  568. --- 240,248 ----
  569. X          ButtonPressMask | ButtonMotionMask | ButtonReleaseMask
  570. X          | ExposureMask | OwnerGrabButtonMask;
  571. X          attributes.win_gravity = whichgrav[which];
  572. !     if (GRV.SpecialResizePointers)
  573. !         attributes.cursor = GRV.CornerPointers[which];
  574. !     else attributes.cursor = GRV.ResizePointer;
  575. X          valuemask = CWEventMask | CWWinGravity | CWCursor;
  576. X  
  577. X          win = XCreateWindow(dpy, par->core.self,
  578. *** BUILD/cursors.c    Sat Jun 13 15:55:20 1992
  579. --- src/cursors.c    Sat Jun 13 15:48:00 1992
  580. ***************
  581. *** 0 ****
  582. --- 1,412 ----
  583. + #include <stdio.h>
  584. + #include <memory.h>
  585. + #include <X11/Xos.h>
  586. + #include <X11/Xlib.h>
  587. + #include <X11/Xutil.h>
  588. + #include <X11/Xresource.h>
  589. + #include <X11/keysym.h>
  590. + #include <X11/cursorfont.h>
  591. + 
  592. + #include "olcursor.h"
  593. + #include "ollocale.h"
  594. + #include "mem.h"
  595. + #include "olwm.h"
  596. + #include "win.h"
  597. + #include "menu.h"
  598. + #include "globals.h"
  599. + #include "screen.h"
  600. + #include "cursors.h"
  601. + #include "i18n.h"
  602. + #include "st.h"
  603. + 
  604. + #ident "@(#)cursors.c    1.1 olvwm version 6/13/92"
  605. + 
  606. + static st_table    *cursorTable;
  607. + static st_table *fontTable;
  608. + 
  609. + typedef struct _cursor_data {
  610. +     char *name;
  611. +     int num;
  612. + };
  613. + 
  614. + static struct _cursor_data cursor_names[] = {
  615. +     { "XC_num_glyphs", XC_num_glyphs },
  616. +     { "XC_X_cursor", XC_X_cursor },
  617. +     { "XC_arrow", XC_arrow },
  618. +     { "XC_based_arrow_down", XC_based_arrow_down },
  619. +     { "XC_based_arrow_up", XC_based_arrow_up },
  620. +     { "XC_boat", XC_boat },
  621. +     { "XC_bogosity", XC_bogosity },
  622. +     { "XC_bottom_left_corner", XC_bottom_left_corner },
  623. +     { "XC_bottom_right_corner", XC_bottom_right_corner },
  624. +     { "XC_bottom_side", XC_bottom_side },
  625. +     { "XC_bottom_tee", XC_bottom_tee },
  626. +     { "XC_box_spiral", XC_box_spiral },
  627. +     { "XC_center_ptr", XC_center_ptr },
  628. +     { "XC_circle", XC_circle },
  629. +     { "XC_clock", XC_clock },
  630. +     { "XC_coffee_mug", XC_coffee_mug },
  631. +     { "XC_cross", XC_cross },
  632. +     { "XC_cross_reverse", XC_cross_reverse },
  633. +     { "XC_crosshair", XC_crosshair },
  634. +     { "XC_diamond_cross", XC_diamond_cross },
  635. +     { "XC_dot", XC_dot },
  636. +     { "XC_dotbox", XC_dotbox },
  637. +     { "XC_double_arrow", XC_double_arrow },
  638. +     { "XC_draft_large", XC_draft_large },
  639. +     { "XC_draft_small", XC_draft_small },
  640. +     { "XC_draped_box", XC_draped_box },
  641. +     { "XC_exchange", XC_exchange },
  642. +     { "XC_fleur", XC_fleur },
  643. +     { "XC_gobbler", XC_gobbler },
  644. +     { "XC_gumby", XC_gumby },
  645. +     { "XC_hand1", XC_hand1 },
  646. +     { "XC_hand2", XC_hand2 },
  647. +     { "XC_heart", XC_heart },
  648. +     { "XC_icon", XC_icon },
  649. +     { "XC_iron_cross", XC_iron_cross },
  650. +     { "XC_left_ptr", XC_left_ptr },
  651. +     { "XC_left_side", XC_left_side },
  652. +     { "XC_left_tee", XC_left_tee },
  653. +     { "XC_leftbutton", XC_leftbutton },
  654. +     { "XC_ll_angle", XC_ll_angle },
  655. +     { "XC_lr_angle", XC_lr_angle },
  656. +     { "XC_man", XC_man },
  657. +     { "XC_middlebutton", XC_middlebutton },
  658. +     { "XC_mouse", XC_mouse },
  659. +     { "XC_pencil", XC_pencil },
  660. +     { "XC_pirate", XC_pirate },
  661. +     { "XC_plus", XC_plus },
  662. +     { "XC_question_arrow", XC_question_arrow },
  663. +     { "XC_right_ptr", XC_right_ptr },
  664. +     { "XC_right_side", XC_right_side },
  665. +     { "XC_right_tee", XC_right_tee },
  666. +     { "XC_rightbutton", XC_rightbutton },
  667. +     { "XC_rtl_logo", XC_rtl_logo },
  668. +     { "XC_sailboat", XC_sailboat },
  669. +     { "XC_sb_down_arrow", XC_sb_down_arrow },
  670. +     { "XC_sb_h_double_arrow", XC_sb_h_double_arrow },
  671. +     { "XC_sb_left_arrow", XC_sb_left_arrow },
  672. +     { "XC_sb_right_arrow", XC_sb_right_arrow },
  673. +     { "XC_sb_up_arrow", XC_sb_up_arrow },
  674. +     { "XC_sb_v_double_arrow", XC_sb_v_double_arrow },
  675. +     { "XC_shuttle", XC_shuttle },
  676. +     { "XC_sizing", XC_sizing },
  677. +     { "XC_spider", XC_spider },
  678. +     { "XC_spraycan", XC_spraycan },
  679. +     { "XC_star", XC_star },
  680. +     { "XC_target", XC_target },
  681. +     { "XC_tcross", XC_tcross },
  682. +     { "XC_top_left_arrow", XC_top_left_arrow },
  683. +     { "XC_top_left_corner", XC_top_left_corner },
  684. +     { "XC_top_right_corner", XC_top_right_corner },
  685. +     { "XC_top_side", XC_top_side },
  686. +     { "XC_top_tee", XC_top_tee },
  687. +     { "XC_trek", XC_trek },
  688. +     { "XC_ul_angle", XC_ul_angle },
  689. +     { "XC_umbrella", XC_umbrella },
  690. +     { "XC_ur_angle", XC_ur_angle },
  691. +     { "XC_watch", XC_watch },
  692. +     { "XC_xterm", XC_xterm },
  693. +     { "OLC_basic", OLC_basic },
  694. +     { "OLC_move", OLC_move },
  695. +     { "OLC_copy", OLC_copy },
  696. +     { "OLC_busy", OLC_busy },
  697. +     { "OLC_stop", OLC_stop },
  698. +     { "OLC_panning", OLC_panning },
  699. +     { "OLC_target", OLC_target },
  700. +     { "OLC_nouse", OLC_nouse },
  701. +     { "OLC_ptr", OLC_ptr },
  702. +     { "OLC_beye", OLC_beye },
  703. +     { "OLC_rtarr", OLC_rtarr },
  704. +     { "OLC_xhair", OLC_xhair },
  705. +     { "OLC_xcurs", OLC_xcurs },
  706. +     { "OLC_hourg", OLC_hourg },
  707. +     { NULL, -1 }
  708. + };
  709. + 
  710. + static int
  711. + cursorHash(a, modulus)
  712. +     register char    *a;
  713. +     register int    modulus;
  714. + {
  715. + int    sum = 0;
  716. + 
  717. +     while (*a)
  718. +     sum += *a++;
  719. +     return sum % modulus;
  720. + }
  721. + 
  722. + #define DEFAULT_CURSOR    XC_left_ptr
  723. + 
  724. + static Font
  725. + resLoadFont(dpy, file)
  726. +     Display *dpy;
  727. +     char *file;
  728. + {
  729. +     Font fid;
  730. + 
  731. +     if (!fontTable)
  732. +     fontTable = st_init_table(strcmp, cursorHash);
  733. +     
  734. +     if (!st_lookup(fontTable, file, &fid)) {
  735. +     if ((fid = XLoadFont(dpy, file)) == 0)
  736. +         fid = (Font) 0;
  737. +     else st_insert(fontTable, file, (char *) fid);
  738. +     }
  739. +     return fid;
  740. + }
  741. + 
  742. + static Bool
  743. + findNextColor(dpy, ptr, xcolor, cmap)
  744. +     Display *dpy;
  745. +     char **ptr;
  746. +     XColor *xcolor;
  747. +     Colormap cmap;
  748. + {
  749. + char *color, tmp;
  750. + Bool return_flag = True;
  751. + 
  752. +     for ( ; **ptr && isspace(**ptr); ++(*ptr))
  753. +     ;    /* read to next space */
  754. + 
  755. +     if (**ptr == '\0')
  756. +     return_flag = False;
  757. +     else {
  758. +     color = *ptr;
  759. + 
  760. +     for ( ; **ptr && !isspace( **ptr ); ++(*ptr) )
  761. +         ;    /* read to next space */
  762. +     tmp = **ptr;
  763. +     **ptr = '\0';
  764. + 
  765. +     if (!XParseColor(dpy, cmap, color, xcolor) ||
  766. +         !XAllocColor(dpy, cmap, xcolor))
  767. +         return_flag = False;
  768. +     **ptr = tmp;
  769. +     }
  770. +     return return_flag;
  771. + }
  772. + 
  773. + static void
  774. + createCursor(dpy, cmap, pointer, cursor_id, font_file, no_colors, colors_p)
  775. +     Display *dpy;
  776. +     Colormap cmap;
  777. +     Cursor *pointer;
  778. +     int cursor_id;
  779. +     char *font_file;
  780. +     Bool no_colors;
  781. +     char *colors_p;
  782. + {
  783. +     static XColor def_bg, def_fg;
  784. +     static Bool def_cols_set = False;
  785. +     XColor fg, bg;
  786. +     Font fid;
  787. +     Bool use_default = False;
  788. + 
  789. +     if (!def_cols_set) {
  790. +     def_fg.pixel = BlackPixel(dpy, DefaultScreen(dpy));
  791. +     XQueryColor(dpy, cmap, &def_fg);
  792. +     def_bg.pixel = WhitePixel(dpy, DefaultScreen(dpy));
  793. +     XQueryColor(dpy, cmap, &def_bg);
  794. +     def_cols_set = True;
  795. +     }
  796. + 
  797. +     if (no_colors) {
  798. +     fg = def_fg;
  799. +     bg = def_bg;
  800. +     }
  801. +     else {
  802. +     char *p = colors_p;
  803. + 
  804. +     if (findNextColor(dpy, (++p, &p), &fg, cmap)) {
  805. +         if (!*p || !findNextColor(dpy, (++p, &p), &bg, cmap))
  806. +         bg = def_bg;
  807. +     }
  808. +     else {
  809. +         fg = def_fg;
  810. +         bg = def_bg;
  811. +     }
  812. +     }
  813. + 
  814. +     if (font_file == NULL || (fid = resLoadFont(dpy, font_file)) == 0)
  815. +     use_default = True;
  816. +     else {
  817. +     if ((*pointer = XCreateGlyphCursor(dpy, fid, fid, cursor_id,
  818. +                          cursor_id+1, &fg, &bg )) == NULL)
  819. +         use_default = True;
  820. +     }
  821. + 
  822. +     if (use_default) {
  823. +     *pointer = XCreateFontCursor(dpy, DEFAULT_CURSOR);
  824. +     XRecolorCursor(dpy, *pointer, &def_fg, &def_bg);
  825. +     }
  826. + }
  827. + 
  828. + static void
  829. + initPointer(dpy, cmap, data, pointer)
  830. +     Display *dpy;
  831. +     Colormap cmap;
  832. +     char *data;
  833. +     Cursor *pointer;
  834. + {
  835. +     char *our_copy, *ptr;
  836. +     Bool end = False;
  837. +     int cursor_id;
  838. +     char *font_file = NULL;
  839. +     char *cursor_id_p;
  840. + 
  841. +     if (data) {
  842. +     our_copy = MemNewString(data);
  843. + 
  844. +     for (ptr = our_copy; *ptr && !isspace( *ptr ); ++ptr)
  845. +         ;
  846. +     if ( *ptr == '\0' )
  847. +         end = True;
  848. +     else *ptr = '\0';
  849. +         
  850. +     if (st_lookup(cursorTable, our_copy, &cursor_id)) {
  851. +         if (our_copy[0] == 'X')
  852. +         font_file = "cursor";
  853. +         else if (our_copy[0] == 'O')
  854. +         font_file = "olcursor";
  855. +         createCursor(dpy, cmap, pointer, cursor_id, font_file, end, ptr);
  856. +     }
  857. +     else {
  858. +         if (end)
  859. +         createCursor(dpy, cmap, pointer, 0, NULL, end, ptr);
  860. +         
  861. +         font_file = our_copy;
  862. +         for (++ptr; *ptr && isspace( *ptr ); ++ptr)
  863. +         ;
  864. +         cursor_id_p = ptr;
  865. +         for (; *ptr && !isspace( *ptr ); ++ptr )
  866. +         ;
  867. +         if ( *ptr == '\0' )
  868. +         end = True;
  869. +         else *ptr = '\0';
  870. +         
  871. +         cursor_id = atoi(cursor_id_p);
  872. +         createCursor(dpy, cmap, pointer, cursor_id, font_file, end, ptr);
  873. +     }
  874. +     MemFree( our_copy );
  875. +     }
  876. + }
  877. + 
  878. + static void
  879. + initOtherPointers(dpy, cmap)
  880. +     Display *dpy;
  881. +     Colormap cmap;
  882. + {
  883. +     initPointer(dpy, cmap, GRV.BasicPointerData, &GRV.BasicPointer);
  884. +     initPointer(dpy, cmap, GRV.MovePointerData, &GRV.MovePointer);
  885. +     initPointer(dpy, cmap, GRV.BusyPointerData, &GRV.BusyPointer);
  886. +     initPointer(dpy, cmap, GRV.IconPointerData, &GRV.IconPointer);
  887. +     initPointer(dpy, cmap, GRV.ResizePointerData, &GRV.ResizePointer);
  888. +     initPointer(dpy, cmap, GRV.MenuPointerData, &GRV.MenuPointer);
  889. +     initPointer(dpy, cmap, GRV.QuestionPointerData, &GRV.QuestionPointer);
  890. +     initPointer(dpy, cmap, GRV.TargetPointerData, &GRV.TargetPointer);
  891. +     initPointer(dpy, cmap, GRV.PanPointerData, &GRV.PanPointer);
  892. +     initPointer(dpy, cmap, GRV.CloseUpPointerData, &GRV.CloseUpPointer);
  893. +     initPointer(dpy, cmap, GRV.CloseDownPointerData, &GRV.CloseDownPointer);
  894. + }
  895. + 
  896. + static Bool
  897. + initResizePointers(dpy, cmap)
  898. +     Display *dpy;
  899. +     Colormap cmap;
  900. + {
  901. + char *ptr;
  902. + Bool colorsIncluded = False;
  903. + char *our_copy;
  904. + XColor colFGC, colBGC, colFGM, colBGM;
  905. + int i;
  906. + 
  907. +     if (GRV.SpecialResizePointerData) {
  908. +     our_copy = MemNewString( GRV.SpecialResizePointerData );
  909. +     for (ptr = our_copy; *ptr && !isspace(*ptr); ++ptr)
  910. +         ;    /* get the first space in ptr */
  911. + 
  912. +     if (*ptr) {
  913. +         colorsIncluded = True;
  914. +         *ptr = '\0';
  915. +     }
  916. + 
  917. +     if (matchBool(our_copy, &GRV.SpecialResizePointers) == True ) {
  918. +         /* Turn on cursors */
  919. + 
  920. +         /* Arrays are in order of enum WhichResize, defined in win.h */
  921. +         GRV.CornerPointers[0] = XCreateFontCursor(dpy, XC_ul_angle);
  922. +         GRV.CornerPointers[1] = XCreateFontCursor(dpy, XC_ur_angle);
  923. +         GRV.CornerPointers[2] = XCreateFontCursor(dpy, XC_ll_angle);
  924. +         GRV.CornerPointers[3] = XCreateFontCursor(dpy, XC_lr_angle);
  925. + 
  926. +         GRV.ResizePointers[0] =
  927. +                   XCreateFontCursor(dpy, XC_top_left_corner);
  928. +         GRV.ResizePointers[1] =
  929. +                   XCreateFontCursor(dpy, XC_top_right_corner);
  930. +         GRV.ResizePointers[2] =
  931. +                   XCreateFontCursor(dpy, XC_bottom_left_corner);
  932. +         GRV.ResizePointers[3] =
  933. +                   XCreateFontCursor(dpy, XC_bottom_right_corner);
  934. +         
  935. +         if (colorsIncluded) {
  936. +         if (!findNextColor(dpy, (++ptr, &ptr), &colFGC, cmap) ||
  937. +            !*ptr || !findNextColor(dpy, (++ptr, &ptr), &colBGC, cmap) ||
  938. +            !*ptr || !findNextColor(dpy, (++ptr, &ptr), &colFGM, cmap) ||
  939. +            !*ptr || !findNextColor(dpy, (++ptr, &ptr), &colBGM, cmap)) {
  940. +             ErrorWarning(gettext("Bad color specification for special resize cursor"));
  941. +             colorsIncluded = False;
  942. +         }
  943. +         }
  944. + 
  945. +         if (!colorsIncluded) {
  946. +         /* if not included, get default colors */
  947. +         colFGC.pixel = BlackPixel(dpy, DefaultScreen(dpy));
  948. +         XQueryColor(dpy, cmap, &colFGC);
  949. + 
  950. +         colBGC.pixel = WhitePixel(dpy, DefaultScreen(dpy));
  951. +         XQueryColor(dpy, cmap, &colBGC);
  952. + 
  953. +         colFGM = colFGC;
  954. +         colBGM = colBGC;
  955. +         }
  956. + 
  957. +         for (i = 0; i < 4; ++i) {
  958. +         XRecolorCursor(dpy, GRV.CornerPointers[i], &colFGC, &colBGC);
  959. +         XRecolorCursor(dpy, GRV.ResizePointers[i], &colFGM, &colBGM);
  960. +         }
  961. +     }
  962. + 
  963. +     MemFree(our_copy);
  964. +     }
  965. +     else return False;
  966. +     return True;
  967. + }
  968. + 
  969. + /*
  970. +  *
  971. +  * ============================================================================
  972. +  * Entry Points
  973. +  */
  974. + 
  975. + void
  976. + InitCursors(dpy, scrInfo)
  977. +     Display *dpy;
  978. +     ScreenInfo *scrInfo;
  979. + {
  980. + Colormap cmap;
  981. + struct _cursor_data    *p;
  982. + 
  983. +     cmap = scrInfo->colormap;
  984. + 
  985. +     cursorTable = st_init_table(strcmp, cursorHash);
  986. + 
  987. +     for (p = cursor_names; p->name; p++)
  988. +     st_insert(cursorTable, (int) p->name, (char *) p->num);
  989. + 
  990. +     if (!initResizePointers(dpy, cmap))
  991. +     GRV.SpecialResizePointers = False;
  992. + 
  993. +     initOtherPointers(dpy, cmap);
  994. + }
  995. *** BUILD/cursors.h    Sat Jun 13 15:55:23 1992
  996. --- src/cursors.h    Sat Jun 13 15:48:00 1992
  997. ***************
  998. *** 0 ****
  999. --- 1,9 ----
  1000. + #ifndef _OLWM_LBL_CURSORS_H
  1001. + #define _OLWM_LBL_CURSORS_H
  1002. + 
  1003. + #ident "@(#)cursors.h    1.1 olvwm version 6/13/92"
  1004. + 
  1005. + extern void InitCursors( /* Display *,  ScreenInfo * */ );
  1006. + extern void updateCursors( /* Display *, char * */ );
  1007. + 
  1008. + #endif
  1009. SHAR_EOF
  1010. echo 'File olvwm3.Patch02 is complete' &&
  1011. chmod 0644 olvwm3.Patch02 ||
  1012. echo 'restore of olvwm3.Patch02 failed'
  1013. Wc_c="`wc -c < 'olvwm3.Patch02'`"
  1014. test 174178 -eq "$Wc_c" ||
  1015.     echo 'olvwm3.Patch02: original size 174178, current size' "$Wc_c"
  1016. rm -f _shar_wnt_.tmp
  1017. fi
  1018. rm -f _shar_seq_.tmp
  1019. echo You have unpacked the last part
  1020. exit 0
  1021. -- 
  1022. ---
  1023. Senior Systems Scientist        mail: dcmartin@msi.com
  1024. Molecular Simulations, Inc.        uucp: uunet!dcmartin
  1025. 796 North Pastoria Avenue        at&t: 408/522-9236
  1026.